package com.ddm.controller.web;

import com.ddm.entity.Bookmark;
import com.ddm.result.Result;
import com.ddm.service.webService.BookmarkService;
import com.ddm.vo.webVo.WebBookmarkVO;
import io.swagger.annotations.ApiOperation;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 收藏控制器
 * 处理收藏相关的HTTP请求
 */
@Slf4j
@RestController
@RequestMapping("/bookmark")
public class WebBookmarkController {

    @Autowired
    private BookmarkService bookmarkService;

    /**
     * 添加收藏记录
     * 使用MyBatis-Plus的insert方法实现
     *
     * @param bookmark 收藏实体（包含userId、courseId/regulationId等字段）
     * @return 统一响应结果
     */
    @PostMapping("/add")
    public WebBookmarkVO addBookmark(@RequestBody Bookmark bookmark) {
        if (bookmark.getUserId() == null) {
            return WebBookmarkVO.fail("用户ID不能为空");
        }
        try {
            bookmarkService.addBookmark(bookmark); // 插入数据
            // 检查是否成功回填了自增ID
            if (bookmark.getId() != null) {
                return WebBookmarkVO.success(bookmark,"收藏成功");
            } else {
                return WebBookmarkVO.fail("添加失败，请重试");
            }
        }catch (RuntimeException e) {
            return WebBookmarkVO.fail(e.getMessage()); // 返回具体错误信息
        }
    }

    /**
     * 删除收藏记录
     *
     * @param bookmark 收藏实体（包含userId、courseId/regulationId等字段）
     * @return 统一响应结果
     */
    @PostMapping("/delete")
    @ApiOperation(value = "删除用户收藏", notes = "需要用户ID和具体收藏内容的ID")
    public WebBookmarkVO deleteBookmark(@RequestBody Bookmark bookmark) {
        try {
            // 调用Service层删除方法，获取删除结果（true=成功，false=失败）
            boolean isDeleted = bookmarkService.deleteBookmark(bookmark);

            // 关键：根据Service返回的删除结果判断，而不是bookmark.getId()
            if (isDeleted) {
                return WebBookmarkVO.success(bookmark, "取消收藏成功");
            } else {
                return WebBookmarkVO.fail("取消收藏失败，未找到对应收藏记录");
            }
        } catch (RuntimeException e) {
            // 捕获业务异常（如参数缺失）
            return WebBookmarkVO.fail(e.getMessage());
        } catch (Exception e) {
            // 捕获其他未知异常
            e.printStackTrace();
            return WebBookmarkVO.fail("系统异常，删除失败");
        }
    }

    /**
     * 检查收藏记录
     *
     * @param bookmark 收藏实体（包含userId、courseId/regulationId等字段）
     * @return is_bookmarked(true是,false否)
     */
    @PostMapping("/check")
    @ApiOperation(value = "检查用户收藏", notes = "需要用户ID和具体收藏内容的ID")
    public Result<Map<String, Boolean>> checkBookmark(@RequestBody Bookmark bookmark) {
        try {
            // 1. 调用服务层获取收藏状态（true/false）
            boolean isBookmark = bookmarkService.checkBookmark(bookmark);
            // 2. 封装为包含is_bookmark字段的Map
            Map<String, Boolean> resultMap = new HashMap<>();
            resultMap.put("is_bookmarked", isBookmark);
            // 3. 使用统一响应工具类返回
            return Result.success(resultMap);
        } catch (RuntimeException e) {
            throw new RuntimeException(e.getMessage());
        }
    }
    
    /**
     * 竞赛报名（收藏即报名）
     *
     * @param bookmark 包含userId和exam_id的收藏实体
     * @return 统一响应结果
     */
    @PostMapping("/register-exam")
    @ApiOperation(value = "竞赛报名", notes = "收藏即报名，需要用户ID和竞赛ID")
    public WebBookmarkVO registerExam(@RequestBody Bookmark bookmark) {
        if (bookmark.getUserId() == null) {
            return WebBookmarkVO.fail("请先登录");
        }
        if (bookmark.getExam_id() == null) {
            return WebBookmarkVO.fail("竞赛ID不能为空");
        }
        try {
            bookmarkService.addBookmark(bookmark); // 插入数据
            // 检查是否成功回填了自增ID
            if (bookmark.getId() != null) {
                return WebBookmarkVO.success(bookmark,"竞赛报名成功");
            } else {
                return WebBookmarkVO.fail("报名失败，请重试");
            }
        }catch (RuntimeException e) {
            return WebBookmarkVO.fail(e.getMessage()); // 返回具体错误信息
        }
    }
    
    /**
     * 取消竞赛报名
     *
     * @param bookmark 包含userId和exam_id的收藏实体
     * @return 统一响应结果
     */
    @PostMapping("/cancel-exam-registration")
    @ApiOperation(value = "取消竞赛报名", notes = "需要用户ID和竞赛ID")
    public WebBookmarkVO cancelExamRegistration(@RequestBody Bookmark bookmark) {
        if (bookmark.getUserId() == null) {
            return WebBookmarkVO.fail("请先登录");
        }
        if (bookmark.getExam_id() == null) {
            return WebBookmarkVO.fail("竞赛ID不能为空");
        }
        try {
            // 调用Service层删除方法，获取删除结果（true=成功，false=失败）
            boolean isDeleted = bookmarkService.deleteBookmark(bookmark);

            if (isDeleted) {
                return WebBookmarkVO.success(bookmark, "取消报名成功");
            } else {
                return WebBookmarkVO.fail("取消报名失败，未找到对应报名记录");
            }
        } catch (RuntimeException e) {
            return WebBookmarkVO.fail(e.getMessage());
        } catch (Exception e) {
            e.printStackTrace();
            return WebBookmarkVO.fail("系统异常，取消报名失败");
        }
    }
    
    /**
     * 检查竞赛报名状态
     *
     * @param userId 用户ID
     * @param examId 竞赛ID
     * @return 报名状态
     */
    @GetMapping("/check-exam-registration")
    @ApiOperation(value = "检查竞赛报名状态", notes = "检查用户是否已报名指定竞赛")
    public Result<Map<String, Boolean>> checkExamRegistration(@RequestParam Long userId, @RequestParam Long examId) {
        try {
            boolean isRegistered = bookmarkService.checkExamRegistration(userId, examId);
            Map<String, Boolean> resultMap = new HashMap<>();
            resultMap.put("is_registered", isRegistered);
            return Result.success(resultMap);
        } catch (Exception e) {
            return Result.error("检查报名状态失败：" + e.getMessage());
        }
    }
    
    /**
     * 获取用户报名的竞赛列表
     *
     * @param userId 用户ID
     * @return 报名的竞赛ID列表
     */
    @GetMapping("/registered-exams")
    @ApiOperation(value = "获取用户报名的竞赛列表", notes = "返回用户已报名的所有竞赛ID")
    public Result<List<Long>> getRegisteredExams(@RequestParam Long userId) {
        try {
            List<Long> examIds = bookmarkService.getRegisteredExamIds(userId);
            return Result.success(examIds);
        } catch (Exception e) {
            return Result.error("获取报名竞赛列表失败：" + e.getMessage());
        }
    }

    /**
     查询用户已收藏的所有供求信息 ID 列表
     */
    @GetMapping ("/supply/list")
    @Operation(summary = "查询用户收藏的供求信息 ID", description = "根据用户 ID，返回该用户已收藏的所有供求信息 ID 列表")
    public Result<List<Bookmark>> getCollectedSupplyIds (
            @Parameter(description = "用户 ID（必填）", required = true)
            @RequestParam Long userId) {
        try {
            // 参数校验
            if (userId == null || userId <= 0) {
                return Result.error ("无效的用户 ID");
            }
            List<Bookmark> supplyIds = bookmarkService.getCollectedSupplyIds(userId);
            log.info("查询用户 [{}] 收藏的供求信息，共 {} 条", userId, supplyIds.size ());
            return Result.success (supplyIds);
        } catch (Exception e) {
            log.error ("查询用户收藏供求信息异常，userId: {}", userId, e);
            return Result.error ("查询收藏供求信息失败：" + e.getMessage ());
        }
    }
}
